home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / lib / include / recovBox.h < prev    next >
Encoding:
C/C++ Source or Header  |  1992-09-21  |  10.4 KB  |  275 lines
  1. /*
  2.  * recovBox.h --
  3.  *
  4.  *    External definitions needed by users of the fast recovery mechanism.
  5.  *
  6.  * Copyright (C) 1985 Regents of the University of California
  7.  * All rights reserved.
  8.  *
  9.  *
  10.  * $Header: /sprite/src/lib/include/RCS/recovBox.h,v 1.13 92/09/21 11:55:42 mgbaker Exp $ SPRITE (Berkeley)
  11.  */
  12.  
  13. #include <sysStats.h>
  14.  
  15. #ifndef _RECOV_BOX
  16. #define _RECOV_BOX
  17.  
  18. /*
  19.  * Parameters to Sys_StatsStub interface (should turn into system call
  20.  * interface!!!!) to the recovery box.  Only values from 0 to 99 may be
  21.  * used by the recovery box and associated functions.  The higher numbers
  22.  * are used in the kernel recovery module and defined in recov.h.
  23.  */
  24.  
  25. #define    RECOV_INIT_OBJ_TYPE        0
  26. #define    RECOV_INSERT_OBJ        1
  27. #define    RECOV_INSERT_ARRAY        2
  28. #define    RECOV_DELETE_OBJ        3
  29. #define    RECOV_UPDATE_OBJ        4
  30. #define    RECOV_RETURN_OBJ        5
  31. #define    RECOV_RETURN_ARRAY        6
  32. #define    RECOV_RETURN_CONTENTS        7
  33. #define    RECOV_GET_OBJECT_SIZE        8
  34. #define RECOV_MAP_TYPE            9
  35. #define RECOV_MAP_OBJ_NUM        10
  36. #define RECOV_TEST_ADD_DELETE        11
  37. #define RECOV_PRINT_REBOOT_TIMES    12
  38. #define RECOV_PRINT_SIZE        13
  39. #define RECOV_TOGGLE_CHECKSUM        14
  40. #define RECOV_TEST_ADD            15
  41.  
  42. /*
  43.  * For testing and timings.  Used with RECOV_TEST_ADD_DELETE test.
  44.  */
  45. typedef struct Recov_Timings {
  46.     int        iterations;
  47.     int        numHandles;
  48. } Recov_Timings;
  49.  
  50. /*
  51.  * An object's ID consists of its type number followed by its ID for that type.
  52.  */
  53. typedef    struct    Recov_ObjectID {
  54.     int        typeID;
  55.     int        objectNumber;
  56. } Recov_ObjectID;
  57.  
  58. /*
  59.  * There is one entry in the table of contents for each object type.  Each
  60.  * entry states the size of the objects for that type, the maximum possible
  61.  * number of objects for that type, and the current number for that type.
  62.  * The index in the table of contents of this entry gives the number of the
  63.  * object type.  There is also a field called "applicationTypeID" used by
  64.  * applications to access this type across crashes without needing to know
  65.  * the order in which types were allocated.  The application can hard-code
  66.  * this number and use it to get the kernel's typeID for this type upon
  67.  * restart.
  68.  */
  69. typedef struct    Recov_ContentsEntry {
  70.     int            objectSize;        /* Size of these objects. */
  71.     int            applicationTypeID;    /* Used by application. */
  72.     int            maxNumObjects;        /* Max num of these objects. */
  73.     int            currentNum;        /* Current num allocated. */
  74.     int            firstFree;        /* First index free list. */
  75. } Recov_ContentsEntry;
  76.  
  77. /*
  78.  **************************************************************************
  79.  * The following structures are all arguments to the interface to maniuplate
  80.  * objects in the recovery box.
  81.  **************************************************************************
  82.  */
  83.  
  84. /*
  85.  * Information necessary to create a new object type.  All the objects will
  86.  * be of the same size, and you must specify the maximum number that will
  87.  * ever exist at once.  The applicationTypeID, described above, is passed
  88.  * in via this structure.
  89.  */
  90. typedef struct Recov_InitObjTypeArgs {
  91.     int                 objectSize;    /* Size of new objects. */
  92.     int                 maxNumObjects;    /* Maximum number of objects allowed. */
  93.     int                 objectType;     /* Out field. */
  94.     int            applicationTypeID;    /* Application's ID to map to
  95.                          * to this type. Can be unset
  96.                          * (<= 0) or set (> 0).  If set,
  97.                          * an error will be  returned
  98.                          * if it's not unique. */
  99.     int            doChecksum;    /* If 1, do checksum.  If 0, don't. */
  100. } Recov_InitObjTypeArgs;
  101.  
  102. /*
  103.  * Information necessary to insert a new object.  The field "objectPtr"
  104.  * points to contents of the new object to insert.
  105.  */
  106. typedef struct Recov_InsertObjArgs {
  107.     int                 typeID;        /* Type number of this object. */
  108.     Address             objectPtr;    /* In field: Ptr to object to insert. */
  109.     Recov_ObjectID      objectID;       /* Out field: new object's ID. */
  110.     int            applicationObjectNum;
  111.                     /* In field: Num that application
  112.                      * can use to get real objectID.
  113.                      * This is so that different
  114.                      * applications can point at
  115.                      * the same object without knowing the
  116.                      * order of inserts, etc.  Also, the
  117.                      * application can guarantee the
  118.                      * uniqueness of the number.  Can be
  119.                      * unset (<= 0) or set (>0).  If set,
  120.                      * an error will be returned if there's
  121.                      * already an object of the same type
  122.                      * with this object ID.  */
  123. } Recov_InsertObjArgs;
  124.  
  125. /*
  126.  * Information necessary to insert a set of new objects.  This is a way
  127.  * of inserting more than one object at a time without interference from
  128.  * other processes doing similar object inserts.  If the routine returns
  129.  * with SUCCESS, then all the objects were inserted.  If it returns FAILURE,
  130.  * then no objects were inserted.  If it panics, the results are undefined.
  131.  */
  132. typedef struct Recov_InsertArrayArgs {
  133.     int                 typeID;        /* Type number of this object. */
  134.     int            numObjs;    /* Number of objects to insert. */
  135.     char        *obuffer;    /* In field: objects to insert. */
  136.     int            *applObjNums;    /* In field: array of application's
  137.                      * object numbers for objects.  May
  138.                      * be NIL. */
  139.     Recov_ObjectID    *objIDBuffer;    /* Out field: array of new objects'
  140.                      * object IDs. */
  141. } Recov_InsertArrayArgs;
  142.  
  143. /*
  144.  * Information necessary to delete an object.
  145.  */
  146. typedef struct Recov_DeleteObjArgs {
  147.     Recov_ObjectID      objectID;     /* ID of the object to delete. */
  148. } Recov_DeleteObjArgs;
  149.  
  150. /*
  151.  * Information necessary to update an object.  The field "objectPtr" points
  152.  * to the new version of the object.
  153.  */
  154. typedef struct Recov_UpdateObjArgs {
  155.     Address             objectPtr;    /* In field: Ptr to object to insert. */
  156.     Recov_ObjectID      objectID;    /* ID of the object to update. */
  157. } Recov_UpdateObjArgs;
  158.  
  159. /*
  160.  * Information necessary to return an object.  The field "objectPtr" must
  161.  * point to allocated memory of at least the size of this type of object.
  162.  */
  163. typedef struct Recov_ReturnObjArgs {
  164.     Address             objectPtr;    /* Out: Buffer for returning object. */
  165.     Recov_ObjectID      objectID;    /* ID of the object to delete. */
  166. } Recov_ReturnObjArgs;
  167.  
  168. /*
  169.  * Information necessary to return all the objects of a given type.
  170.  * There are 2 buffers returned:  the first is the array of objects of the
  171.  * given type, and the second is an array giving the ID's of the objects
  172.  * of the corresponding index in the first buffer.
  173.  * The "length" fields specify the current allocated lengths of the
  174.  * return buffers.  Upon successful return, the "length" fields will
  175.  * specify how much of each buffer was used.  Upon failure, the length 
  176.  * fields will specify the needed space for the buffers if the reason for
  177.  * failure was that they weren't large enough.
  178.  */
  179. typedef    struct Recov_ReturnArrayArgs {
  180.     int            typeID;        /* Type number of objects to return. */ 
  181.     int            olength;    /* In/out field for buffer length. */
  182.     char        *obuffer;    /* Out field for object array. */
  183.     int            ilength;    /* In/out field for id buffer length. */
  184.     char        *ibuffer;    /* Out field for object id array. */
  185.     int            alength;    /* In/out field for appl. obj. nums. */
  186.     char        *abuffer;    /* Out field for appl. obj. numbers. */
  187. } Recov_ReturnArrayArgs;
  188.  
  189. /*
  190.  * Information necessary to return the table of contents for the recovery box.
  191.  * The field "length" specifies the current allocated length of the
  192.  * return buffer.  Upon successful return, the "length" field will
  193.  * specify how much of that buffer was used.  Upon failure, the length 
  194.  * field will specify the needed space for the buffer if the reason for
  195.  * failure was that it wasn't large enough.
  196.  */
  197. typedef struct Recov_ReturnTableArgs {
  198.     int            length;        /* In/out field for buffer length. */
  199.     char        *buffer;    /* Out field for contents buffer. */
  200. } Recov_ReturnTableArgs;
  201.  
  202. /*
  203.  * Information necessary to return the size of a given type of object in
  204.  * the box.
  205.  */
  206. typedef    struct Recov_GetObjectSizeArgs {
  207.     int            typeID;        /* In field to give object type. */
  208.     int            objectSize;    /* Out field to return size. */
  209. } Recov_GetObjectSizeArgs;
  210.  
  211. /*
  212.  * Information necessary to map the application's type ID to the real type
  213.  * ID used by the recovery box.
  214.  */
  215. typedef    struct Recov_MapTypeArgs {
  216.     int            applicationTypeID;    /* In field: object type. */
  217.     int            typeID;            /* Out field: real type. */
  218. } Recov_MapTypeArgs;
  219.  
  220. /*
  221.  * Information necessary to map the application's object number to the real
  222.  * object number used by the recovery box.
  223.  */
  224. typedef    struct Recov_MapObjectNumArgs {
  225.     int            realTypeID;    /* In: recov box's type for object */
  226.     int            applicationObjectNum;    /* In: Obj numD to map from. */
  227.     int            realObjectNum;        /* Out field: real obj num. */
  228. } Recov_MapObjectNumArgs;
  229.  
  230.  
  231. /*
  232.  * Defines to make the system call interface look like a library interface,
  233.  * since the sys call interface uses the gross Sys_Stats stuff.
  234.  */
  235. #define    RecovBox_InitObjType(/* (Recov_InitObjTypeArgs *) */ initArgsPtr) \
  236.     Sys_Stats(SYS_RECOV_BOX, RECOV_INIT_OBJ_TYPE, (Address) initArgsPtr)
  237.  
  238. #define    RecovBox_InsertObj(/* (Recov_InsertObjArgs *) */ insertArgsPtr)    \
  239.     Sys_Stats(SYS_RECOV_BOX, RECOV_INSERT_OBJ, (Address) insertArgsPtr)
  240.  
  241. #define    RecovBox_InsertArray(/* (Recov_InsertObjArgs *) */ insertArrayArgsPtr)\
  242.     Sys_Stats(SYS_RECOV_BOX, RECOV_INSERT_ARRAY, (Address) insertArrayArgsPtr)
  243.  
  244. #define    RecovBox_DeleteObj(/* (Recov_DeleteObjArgs *) */ deleteArgsPtr)    \
  245.     Sys_Stats(SYS_RECOV_BOX, RECOV_DELETE_OBJ, (Address) deleteArgsPtr)
  246.  
  247. #define    RecovBox_UpdateObj(/* (Recov_UpdateObjArgs *) */ updateArgsPtr)    \
  248.     Sys_Stats(SYS_RECOV_BOX, RECOV_UPDATE_OBJ, (Address) updateArgsPtr)
  249.  
  250. #define    RecovBox_ReturnObj(/* (Recov_ReturnObjArgs *) */ returnObjArgsPtr) \
  251.     Sys_Stats(SYS_RECOV_BOX, RECOV_RETURN_OBJ, (Address) returnObjArgsPtr)
  252.  
  253. #define    RecovBox_ReturnArray(/* (Recov_ReturnArrayArgs *) */returnArrayArgsPtr)\
  254.     Sys_Stats(SYS_RECOV_BOX, RECOV_RETURN_ARRAY, (Address) returnArrayArgsPtr)
  255.  
  256. #define    RecovBox_ReturnContents(/* (Recov_ReturnTableArgs *) */ \
  257.     returnContentsArgsPtr)\
  258.     Sys_Stats(SYS_RECOV_BOX, RECOV_RETURN_CONTENTS,    \
  259.     (Address) returnContentsArgsPtr)
  260.  
  261. #define RecovBox_GetObjectSize(/* (Recov_GetObjectSizeArgs *) */ \
  262.     getObjectSizeArgsPtr) \
  263.     Sys_Stats(SYS_RECOV_BOX, RECOV_GET_OBJECT_SIZE, \
  264.     (Address) getObjectSizeArgsPtr)
  265.  
  266. #define RecovBox_MapType(/*(Recov_MapTypeArgs *)*/ mapTypeArgsPtr) \
  267.     Sys_Stats(SYS_RECOV_BOX, RECOV_MAP_TYPE, (Address) mapTypeArgsPtr)
  268.  
  269. #define RecovBox_MapObjectNum(/*(Recov_MapObjectNumArgs *)*/ \
  270.     mapObjectNumArgsPtr) \
  271.     Sys_Stats(SYS_RECOV_BOX, RECOV_MAP_OBJ_NUM, (Address) mapObjectNumArgsPtr)
  272.  
  273.  
  274. #endif /* _RECOV_BOX */
  275.